import sdk from '../index';
import { ServerTaskProgress, TaskSystemData, PlayerTaskProgress } from '../rpg/types/task';

/**
 * 任务数据库管理类
 * 职责：
 * 1. 全服任务进度的数据库存储和读取
 * 2. 玩家任务数据的数据库存储和读取
 * 3. 任务排行榜数据的数据库存储和读取
 */
class TaskManage {
    // 数据库集合名称
    private readonly SERVER_TASK_PROGRESS_COLLECTION = 'server_task_progress';
    private readonly PLAYER_TASK_DATA_COLLECTION = 'player_task_data';
    
    // 内存缓存
    private serverTaskProgressCache: Map<string, ServerTaskProgress> = new Map();
    private playerTaskDataCache: Map<string, TaskSystemData> = new Map();

    /**
     * 初始化任务管理系统
     */
    async init() {
        try {
            console.log('初始化任务管理系统...');
            
            // 加载全服任务进度到内存
            await this.loadServerTaskProgress();
            
            console.log('任务管理系统初始化完成');
        } catch (error) {
            console.error('任务管理系统初始化失败:', error);
        }
    }

    /**
     * 加载全服任务进度到内存
     */
    private async loadServerTaskProgress() {
        try {
            const serverTasks = await sdk.db.find(this.SERVER_TASK_PROGRESS_COLLECTION);
            this.serverTaskProgressCache.clear();
            
            serverTasks.forEach((task: any) => {
                this.serverTaskProgressCache.set(task.taskId, {
                    taskId: task.taskId,
                    totalProgress: task.totalProgress || 0,
                    participantCount: task.participantCount || 0,
                    completedCount: task.completedCount || 0,
                    lastUpdateTime: task.lastUpdateTime || Date.now()
                });
            });
            
            console.log(`加载了 ${this.serverTaskProgressCache.size} 个全服任务进度到内存`);
        } catch (error) {
            console.error('加载全服任务进度失败:', error);
        }
    }



    /**
     * 获取全服任务进度
     * @param taskId 任务ID
     * @returns 全服任务进度
     */
    getServerTaskProgress(taskId: string): ServerTaskProgress | null {
        return this.serverTaskProgressCache.get(taskId) || null;
    }

    /**
     * 更新全服任务进度
     * @param taskId 任务ID
     * @param progress 进度增量
     * @param participantCount 参与玩家数（可选）
     * @returns 更新结果
     */
    updateServerTaskProgress(
        taskId: string, 
        progress: number = 1, 
        participantCount?: number
    ): {
        success: boolean;
        message: string;
        serverProgress?: ServerTaskProgress;
    } {
        try {
            // 获取当前进度
            const currentProgress = this.getServerTaskProgress(taskId);
            const newTotalProgress = (currentProgress?.totalProgress || 0) + progress;
            const newParticipantCount = participantCount || (currentProgress?.participantCount || 0) + 1;

            const serverProgress: ServerTaskProgress = {
                taskId,
                totalProgress: newTotalProgress,
                participantCount: newParticipantCount,
                completedCount: currentProgress?.completedCount || 0,
                lastUpdateTime: Date.now()
            };

            // 更新内存缓存
            this.serverTaskProgressCache.set(taskId, serverProgress);

            return {
                success: true,
                message: '全服任务进度更新成功',
                serverProgress
            };
        } catch (error) {
            console.error(`更新全服任务进度失败 (taskId: ${taskId}):`, error);
            return {
                success: false,
                message: '更新全服任务进度失败'
            };
        }
    }

    /**
     * 获取玩家任务数据
     * @param playerId 玩家ID
     * @returns 玩家任务数据
     */
    getPlayerTaskData(playerId: string): TaskSystemData | null {
        return this.playerTaskDataCache.get(playerId) || null;
    }

    /**
     * 保存玩家任务数据
     * @param playerId 玩家ID
     * @param taskData 任务数据
     * @returns 保存结果
     */
    savePlayerTaskData(playerId: string, taskData: TaskSystemData): {
        success: boolean;
        message: string;
    } {
        try {
            // 更新内存缓存
            this.playerTaskDataCache.set(playerId, taskData);

            return {
                success: true,
                message: '玩家任务数据保存成功'
            };
        } catch (error) {
            console.error(`保存玩家任务数据失败 (playerId: ${playerId}):`, error);
            return {
                success: false,
                message: '保存玩家任务数据失败'
            };
        }
    }



    /**
     * 重置全服任务进度
     * @returns 重置结果
     */
    resetServerTaskProgress(): {
        success: boolean;
        message: string;
        resetCount: number;
    } {
        try {
            // 清空内存缓存
            this.serverTaskProgressCache.clear();
            
            console.log('全服任务进度重置完成');
            
            return {
                success: true,
                message: '全服任务进度重置成功',
                resetCount: 0
            };
        } catch (error) {
            console.error('重置全服任务进度失败:', error);
            return {
                success: false,
                message: '重置全服任务进度失败',
                resetCount: 0
            };
        }
    }

    /**
     * 保存所有数据到数据库
     */
    async save() {
        try {
            console.log('保存任务数据到数据库...');
            
            // 批量保存全服任务进度
            if (this.serverTaskProgressCache.size > 0) {
                const serverTasksToSave = Array.from(this.serverTaskProgressCache.values());
                for (const taskProgress of serverTasksToSave) {
                    await sdk.db.update(
                        this.SERVER_TASK_PROGRESS_COLLECTION,
                        { taskId: taskProgress.taskId },
                        taskProgress
                    );
                }
                console.log(`保存了 ${serverTasksToSave.length} 个全服任务进度到数据库`);
            }
            
            // 批量保存玩家任务数据
            if (this.playerTaskDataCache.size > 0) {
                const playerTasksToSave = Array.from(this.playerTaskDataCache.entries());
                for (const [playerId, taskData] of playerTasksToSave) {
                    await sdk.db.update(
                        this.PLAYER_TASK_DATA_COLLECTION,
                        { playerId },
                        { playerId, ...taskData, lastUpdateTime: Date.now() }
                    );
                }
                console.log(`保存了 ${playerTasksToSave.length} 个玩家任务数据到数据库`);
            }
            
            console.log('任务数据保存完成');
        } catch (error) {
            console.error('保存任务数据失败:', error);
        }
    }
}

export default new TaskManage(); 